home *** CD-ROM | disk | FTP | other *** search
/ Aminet 38 / Aminet 38 (2000)(Schatztruhe)[!][Aug 2000].iso / Aminet / util / moni / Scout-src.lha / src / objects / scout_locks.c < prev    next >
Encoding:
C/C++ Source or Header  |  2000-03-09  |  10.4 KB  |  302 lines
  1. /**
  2.  * Scout - The Amiga System Monitor
  3.  *
  4.  *------------------------------------------------------------------
  5.  *
  6.  * This program is free software; you can redistribute it and/or modify
  7.  * it under the terms of the GNU General Public License as published by
  8.  * the Free Software Foundation; either version 2 of the License, or
  9.  * any later version.
  10.  *
  11.  * This program is distributed in the hope that it will be useful,
  12.  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  13.  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14.  * GNU General Public License for more details.
  15.  *
  16.  * You should have received a copy of the GNU General Public License
  17.  * along with this program; if not, write to the Free Software
  18.  * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  19.  *
  20.  * You must not use this source code to gain profit of any kind!
  21.  *
  22.  *------------------------------------------------------------------
  23.  *
  24.  * @author Andreas Gelhausen
  25.  * @author Richard Körber <rkoerber@gmx.de>
  26.  */
  27.  
  28.  
  29.  
  30. #include "scout_locks.h"
  31.  
  32. extern struct ExecBase     *SysBase;
  33. extern struct DosLibrary   *DOSBase;
  34.  
  35. #define  LockPuddleSize 1024
  36. #define  LockThreshSize 512
  37.  
  38. APTR LockPool = NULL;
  39.  
  40. int lockanzahl, hiddenanzahl;
  41.  
  42. __asm LONG locklist_dspfunc(register __a2 char **array, register __a1 struct LockEntry *lockentry, register __a0 struct Hook *hook) {
  43.    if (lockentry) {
  44.       *array++ = lockentry->lock_address;
  45.       *array++ = lockentry->lock_access;
  46.       *array++ = lockentry->lock_path;
  47.       *array   = NULL;
  48.    } else {
  49.       *array++ = ESC "bAddress";
  50.       *array++ = ESC "bAccess";
  51.       *array++ = ESC "bPath";
  52.       *array++ = NULL;
  53.    }
  54.    return(0);
  55. }
  56.  
  57. struct Hook locklist_dsphook = {
  58.  {NULL, NULL},
  59.  (ULONG (* )())locklist_dspfunc,
  60.  NULL, NULL
  61. };
  62.  
  63. void FreeLocks (void) {
  64.    if (LockPool) {
  65.       if (AP_Scout) {
  66.          set (locktext,MUIA_Text_Contents,"");
  67.          set (locktext2,MUIA_Text_Contents,"");
  68.          DoMethod (locklist,MUIM_List_Clear);
  69.       }
  70.       AsmDeletePool (LockPool,SysBase);
  71.       LockPool = NULL;
  72.    }
  73. }
  74.  
  75. APTR GetLocks (int sl_job, char *pattern, struct LockEntry **first) {
  76.    struct   LockEntry      *lockentry,*previous = NULL;
  77.    struct   DosList        *dev;
  78.    unsigned long           lock = 0, next, prev, lock2remove = 0;
  79.    struct   FileLock       *lockptr;
  80.    struct   FileInfoBlock  *infoBlock;
  81.    APTR     LocalPool = NULL;
  82.  
  83.    unsigned char  *dest;
  84.    unsigned char  access[6];
  85.  
  86.    int   erster, pattern_correct, i = LOCKSUPDATERATE;
  87.  
  88.    if (first)
  89.       *first = 0;
  90.  
  91.    lockanzahl = 0;
  92.    hiddenanzahl = 0;
  93.    NoReqOn();
  94.  
  95.    LocalPool = AsmCreatePool (MEMF_ANY|MEMF_CLEAR,LockPuddleSize,LockThreshSize,SysBase);
  96.  
  97.    if (dest = AllocMem (PATHLENGTH*2+3, MEMF_CLEAR|MEMF_ANY)) {
  98.       pattern_correct = ((((!pattern) || (*pattern == '\0')) && \
  99.          (ParsePatternNoCase ("#?", dest, PATHLENGTH*2+2) != -1)) || \
  100.          (ParsePatternNoCase (pattern, dest, PATHLENGTH*2+2) != -1));
  101.  
  102.       if (clientstate) {
  103.          char  tmpbuffer[256];
  104.    
  105.          if (SendDaemon ("GetLockList")) {
  106.             while ((lockentry = AsmAllocPooled (LocalPool,sizeof (struct LockEntry),SysBase)) \
  107.               && (ReceiveDecodedEntry ((UBYTE *) lockentry, sizeof (struct LockEntry) - 4)) \
  108.               && (sgets (client_socket, tmpbuffer, 256))) {
  109.    
  110.                IsHex (lockentry->lock_address, (long *) &lockentry->lock_ptr);
  111.    
  112.                if (MatchPatternNoCase (dest, tmpbuffer)) {
  113.                   if (lockentry->lock_path = AsmAllocPooled (LocalPool, strlen (tmpbuffer) + 1, SysBase)) {
  114.                      strncpy (lockentry->lock_path, tmpbuffer, strlen (tmpbuffer) + 1);
  115.                   }
  116.                   lockanzahl ++;
  117.    
  118.                   if (! *first)
  119.                      *first = lockentry;
  120.                   if (previous)
  121.                      previous->lock_next = lockentry;
  122.    
  123.                   previous = lockentry;
  124.                } else {
  125.                   hiddenanzahl++;
  126.                }
  127.                if (WI_Locks && !--i) {
  128.                   sprintf (tmpstr, "%d shown, %d hidden...", lockanzahl, hiddenanzahl);
  129.                   i = LOCKSUPDATERATE;
  130.                   DoMethod (AP_Scout,MUIM_Application_InputBuffered);
  131.                   set (locktext2,MUIA_Text_Contents,tmpstr);
  132.                }
  133.             }
  134.          }
  135.       } else {
  136.          if ((pattern_correct) && (infoBlock = AllocMem (sizeof (struct FileInfoBlock), MEMF_CLEAR|MEMF_ANY))) {
  137.             dev = DOSLIST;
  138.             while (dev != 0) {
  139.                if (dev->dol_Type == DLT_VOLUME){
  140.                   strncpy (tmpstr, (unsigned char *) ((dev->dol_Name)<<2)+1, FILENAMELENGTH);
  141.                   strcat (tmpstr, ":");
  142.    
  143.                   if (lock = Lock (tmpstr, ACCESS_READ)) {
  144.                      erster = TRUE; next = 0;
  145.    
  146.                      while ((next && (next != lock)) || (erster)) {
  147.                         if (erster)
  148.                            next = lock;
  149.                         lockptr = (struct FileLock *) (next<<2);
  150.                         if (!TypeOfMem (lockptr))
  151.                            break;
  152.                         if (lockptr->fl_Volume != ((ULONG) dev)>>2)
  153.                            break;
  154.                         if (Examine (next, infoBlock)) {
  155.                            if (sl_job == SL_LIST) {
  156.                               if (erster) {
  157.                                  strcpy(access, "OWN");
  158.                               } else if (lockptr->fl_Access == ACCESS_READ) {
  159.                                  strcpy(access, "READ");
  160.                               } else if (lockptr->fl_Access == ACCESS_WRITE) {
  161.                                  strcpy(access, "WRITE");
  162.                               } else {
  163.                                  strcpy(access, "----");
  164.                               }
  165.                            }
  166.                            NameFromLock (next, tmpstr, PATHLENGTH);
  167.                         
  168.                            if (MatchPatternNoCase (dest, tmpstr)) {
  169.                               if ((sl_job == SL_LIST) && (lockentry = AsmAllocPooled (LocalPool,sizeof (struct LockEntry),SysBase))) {
  170.                                  if (! *first)
  171.                                     *first = lockentry;
  172.                                  if (previous)
  173.                                     previous->lock_next = lockentry;
  174.    
  175.                                  lockentry->lock_ptr = (char *) lockptr;
  176.                                  sprintf (lockentry->lock_address, "$%08x", lockptr);
  177.                                  strcpy (lockentry->lock_access, access);
  178.    
  179.                                  if (lockentry->lock_path = AsmAllocPooled (LocalPool, strlen (tmpstr) + 1,SysBase)) {
  180.                                     strcpy (lockentry->lock_path, tmpstr);
  181.                                  }
  182.    
  183.                                  lockanzahl ++;
  184.                                  previous = lockentry;
  185.                               } else if (sl_job == SL_REMOVE) {
  186.                                  lockanzahl ++;
  187.                                  lock2remove = next;
  188.                               } else if (sl_job == SL_COUNT) {
  189.                                  lockanzahl ++;
  190.                               } else {
  191.                                  hiddenanzahl++;
  192.                               }
  193.                            } else {
  194.                               hiddenanzahl++;
  195.                            }
  196.                            if ((WI_Locks) && (sl_job == SL_LIST) && (!(--i))) {
  197.                               sprintf (tmpstr, "%d shown, %d hidden...", lockanzahl, hiddenanzahl);
  198.                               i = LOCKSUPDATERATE;
  199.                               DoMethod (AP_Scout,MUIM_Application_InputBuffered);
  200.                               set (locktext2,MUIA_Text_Contents,tmpstr);
  201.                            }
  202.                         }
  203.                         erster = FALSE;
  204.                         prev = next;
  205.                         next = lockptr->fl_Link;
  206.                         if ((sl_job == SL_REMOVE) && (lock2remove)) {
  207.                            UnLock (lock2remove);
  208.                            lock2remove = NULL;
  209.                         }
  210.                      }
  211.                      UnLock (lock);
  212.                      lock = 0;
  213.                   }
  214.                }
  215.                dev = (struct DosList *) ((dev->dol_Next)<<2);
  216.             }
  217.             FreeMem (infoBlock, sizeof (struct FileInfoBlock));
  218.          }
  219.          NoReqOff();
  220.       }
  221.       FreeMem (dest, PATHLENGTH*2+3);
  222.    }
  223.    return (LocalPool);
  224. }
  225.  
  226. void PrintLocks (char *filename) {
  227.    int   i=1;
  228.    BPTR  handle;
  229.    APTR  lockpool = NULL;
  230.    struct LockEntry *entryp;
  231.  
  232.    handle = HandlePrintStart (filename);
  233.    if ((handle) && (PrintOneLine (handle, "\n  Address  Access  Path\n\n"))) {
  234.       if (! WI_Locks) {
  235.          lockpool = GetLocks (SL_LIST, "#?", &entryp);
  236.       }
  237.       if (i) {
  238.          for (i=0;;i++) {
  239.             if (WI_Locks)
  240.                DoMethod (locklist,MUIM_List_GetEntry,i,&entryp);
  241.             if (!entryp) break;
  242.  
  243.             sprintf (tmpstr2, " %ls  %-5ls  %ls\n", entryp->lock_address, entryp->lock_access, entryp->lock_path);
  244.             if (! (PrintOneLine (handle, tmpstr2)))
  245.                break;
  246.  
  247.             if (! WI_Locks)
  248.                entryp = entryp->lock_next;
  249.          }
  250.       }
  251.    }
  252.    if (lockpool)
  253.       AsmDeletePool (lockpool,SysBase);
  254.    HandlePrintStop();
  255. }
  256.  
  257. void ShowLocks (void) {
  258.    unsigned char        *pattern;
  259.    struct   LockEntry   *lock;
  260.  
  261.    ApplicationSleep();
  262.    set (locklist,MUIA_List_Quiet,TRUE);
  263.    set (locklist,MUIA_List_CompareHook,locklist_cmphook_ptr);
  264.    set (BT_LockRemove, MUIA_Disabled, TRUE);
  265.  
  266.    FreeLocks();
  267.  
  268.    get (lockpattern, MUIA_String_Contents, &pattern);
  269.    LockPool = GetLocks (SL_LIST, pattern, &lock);
  270.  
  271.    while (lock) {
  272.       InsertSortedEntry (locklist, (APTR *) &lock);
  273.       lock = lock->lock_next;
  274.    }
  275.  
  276.    AwakeApplication();
  277.    set (locklist, MUIA_List_Quiet, FALSE);
  278.    MySetContents (locktext2, "%d shown, %d hidden. Done.", lockanzahl, hiddenanzahl);
  279.    set (WI_Locks,MUIA_Window_ActiveObject,locklist);
  280. }
  281.  
  282. void SendLockList (void) {
  283.    unsigned char        *pattern;
  284.    struct   LockEntry   *lock;
  285.  
  286.    FreeLocks();
  287.  
  288.    get (lockpattern, MUIA_String_Contents, &pattern);
  289.    LockPool = GetLocks (SL_LIST, pattern, &lock);
  290.  
  291.    while (lock) {
  292.       SendEncodedEntry ((UBYTE *) lock, sizeof (struct LockEntry) - 4);
  293.       if (lock->lock_path && lock->lock_path[0])
  294.          SendClient ((UBYTE *) lock->lock_path);
  295.       else
  296.          SendClient (" ");
  297.       lock = lock->lock_next;
  298.    }
  299.    FreeLocks();
  300. }
  301.  
  302.